<?php
namespace Core\Redis;

/**
 *  redisDrive.class.php
 *  php redis 操作类
 **/
class Redis
{
    // 连接是否成功
    public $redis;
    // 连接redis服务器ip
    public $ip = '127.0.0.1';
    // 端口
    public $port = 6379;
    // 密码
    public $password = '65c1a6f1688fd';
    // 选择数据库
    public $dbindex = "0";

    // 私有的构造方法
    public function __construct()
    {
        try {
            if (extension_loaded('redis')) {
                $this->redis = new \Redis();
                $this->redis->connect($this->ip, $this->port);
                $this->redis->auth($this->password);
                $this->redis->select($this->dbindex);
            } else {
                $this->redis = false;
            }
        } catch (Exception $e) {

            $this->redis = false;
        }
    }

    // 私有的克隆方法
    private function __clone()
    {
    }

    /**
     * connect redis
     */
    public function connect()
    {
        if ($this->redis->connect($this->ip, $this->port, 1)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 释放资源
     */
    public function close()
    {
        $this->redis->close();
    }

    /**
     * ***********************操作键key begin***************************************
     */
    /**
     * 查找符合给定模式的key。
     * KEYS *命中数据库中所有key。
     * KEYS h?llo命中hello， hallo and hxllo等。
     * KEYS h*llo命中hllo和heeeeello等。
     * KEYS h[ae]llo命中hello和hallo，但不命中hillo。
     * 特殊符号用"\"隔开
     *
     * @param string $name
     * @return 返回符合给定模式的key列表。
     */
    public function getKeys($key)
    {
        if (empty ($key)) {
            $key = "*";
        }
        return $this->redis->keys($key);
    }

    /**
     * 移除给定的一个或多个key。
     * 如果key不存在，则忽略该命令
     *
     * @param string $name
     */
    public function delKeys($key)
    {
        return $this->redis->del($key);
    }

    /**
     * 检查给定key是否存在。
     *
     * @param string $name
     *            若key存在，返回1，否则返回0。
     */
    public function exists($key)
    {
        return $this->redis->exists($key);
    }

    /**
     * 移除已经存在KEYS
     *
     * @param array $keys
     */
    public function deletes($keys)
    {
        return $this->redis->delete($keys);
    }

    /**
     * 返回key所储存的值的类型。
     * none(key不存在) int(0)
     * string(字符串) int(1)
     * list(列表) int(3)
     * set(集合) int(2)
     * zset(有序集) int(4)
     * hash(哈希表) int(5)
     *
     * @param string $key
     */
    public function type($key)
    {
        return $this->redis->type($key);
    }

    /**
     * 排序，分页等
     * 参数
     * array(
     * 'by' => 'some_pattern_*', //通过哪个key进行排序
     * 'limit' => array(0, 1), //限定条数
     * 'get' => 'some_other_pattern_*' or an array of patterns,//获取结果数据
     * 'sort' => 'asc' or 'desc', //排序
     * 'alpha' => TRUE, //按字母顺序
     * 'store' => 'external-key' //将排序内容保存到指定key中
     * )
     * 返回或保存给定列表、集合、有序集合key中经过排序的元素。
     * 排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较。
     *
     * @param string $key
     * @param array $condition
     */
    public function sort($key, $condition)
    {
        return $this->redis->sort($key, $condition);
    }

    /**
     * ***********************操作键key end***************************************
     */

    /**
     * ***********************操作string类型数据 begin***************************************
     */
    /**
     * 将字符串值value关联到key。
     * 如果key已经持有其他值，SET就覆写旧值，无视类型。
     * 总是返回OK(TRUE)，因为SET不可能失败。
     *
     * @param string $key
     * @param string $value
     */
    public function set($key, $value)
    {
        return $this->redis->set($key, $value);
    }

    /**
     * 将key的值设为value，当且仅当key不存在。
     * 若给定的key已经存在，则SETNX不做任何动作。
     * 设置成功，返回true。
     * 设置失败，返回false。
     *
     * @param string $key
     * @param string $value
     */
    public function setNx($key, $value)
    {
        return $this->redis->setNx($key, $value);
    }

    /**
     * 将值value关联到key，并将key的生存时间设为seconds(以秒为单位)。
     * 如果key 已经存在，SETEX命令将覆写旧值。
     * 设置成功时返回OK
     * 当seconds参数不合法时，返回一个错误。
     *
     * @param string $key
     * @param string $value
     * @param int $time
     */
    public function setEx($key, $seconds, $value)
    {
        return $this->redis->setEx($key, $seconds, $value);
        //return $this->redis::setex::etex('key', 3600, 'value');

    }

    /**
     * 用value参数覆写(Overwrite)给定key所储存的字符串值，从偏移量offset开始。
     * 不存在的key当作空白字符串处理。
     *
     * @param string $key
     * @param string $value
     * @param int $offset
     */
    public function setRange($key, $value, $offset)
    {
        return $this->redis->setRange($key, $offset, $value);
    }

    /**
     * 同时设置一个或多个key-value对。
     * 当发现同名的key存在时，MSET会用新值覆盖旧值，如果你不希望覆盖同名key，请使用MSETNX命令。
     *
     * @param array $arrays
     */
    public function mSet($arrays)
    {
        return $this->redis->mSet($arrays);
    }

    /**
     * 同时设置一个或多个key-value对，当且仅当key不存在。
     * 当所有key都成功设置，返回1。
     * 如果所有key都设置失败(最少有一个key已经存在)，那么返回0。
     *
     * @param array $arrays
     */
    public function mSetNx($arrays)
    {
        return $this->redis->mSetNx($arrays);
    }

    /**
     * 如果key已经存在并且是一个字符串，APPEND命令将value追加到key原来的值之后。
     * 如果key不存在，APPEND就简单地将给定key设为value，就像执行SET key value一样。
     *
     * @param string $key
     * @param string $value
     */
    public function appendKey($key, $value)
    {
        return $this->redis->append($key, $value);
    }

    /**
     * 返回key所关联的字符串值。
     * 如果key不存在则返回特殊值nil。
     *
     * @param string $key
     */
    public function get($key)
    {
        return $this->redis->get($key);
    }

    /**
     * 返回所有(一个或多个)给定key的值。
     * 如果某个指定key不存在，返回false。
     * 因此，该命令永不失败。
     *
     * @param array $arrays
     */
    public function mGet($arrays)
    {
        return $this->redis->mGet($arrays);
    }

    /**
     * 返回key中字符串值的子字符串，字符串的截取范围由start和end两个偏移量决定(包括start和end在内)。
     * 负数偏移量表示从字符串最后开始计数，-1表示最后一个字符，-2表示倒数第二个，以此类推。
     *
     * @param string $key
     * @param int $start
     * @param int $end
     */
    public function getRange($key, $start, $end)
    {
        return $this->redis->getRange($key, $start, $end);
    }

    /**
     * 将给定key的值设为value，并返回key的旧值。
     * 当key存在但不是字符串类型时，返回一个错误。
     *
     * @param unknown $key
     * @param unknown $value
     */
    public function getSet($key, $value)
    {
        return $this->redis->getSet($key, $value);
    }

    /**
     * 返回key所储存的字符串值的长度。
     * 当key储存的不是字符串值时，返回一个错误。
     *
     * @param string $key
     */
    public function strlen($key)
    {
        return $this->redis->strlen($key);
    }

    /**
     * 将key中储存的数字值增一。
     * 如果key不存在，以0为key的初始值，然后执行INCR操作。
     * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
     *
     * @param string $key
     */
    public function incr($key)
    {
        return $this->redis->incr($key);
    }

    /**
     * 将key所储存的值加上增量num。
     * 如果key不存在，以0为key的初始值，然后执行INCRBY命令。
     * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
     *
     * @param string $key
     * @param int $num
     */
    public function incrBy($key, $num)
    {
        return $this->redis->incrBy($key, $num);
    }

    /**
     * 将key中储存的数字值减一。
     * 如果key不存在，以0为key的初始值，然后执行DECR操作。
     * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
     *
     * @param string $key
     */
    public function decr($key)
    {
        return $this->redis->decr($key);
    }

    /**
     * 将key所储存的值减去增量num。
     * 如果key不存在，以0为key的初始值，然后执行DECRBY命令。
     * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
     *
     * @param string $key
     * @param int $num
     */
    public function decrBy($key, $num)
    {
        return $this->redis->decrBy($key, $num);
    }
    /**
     * ***********************操作string类型数据 end***************************************
     */

    /**
     * ***********************操作哈希表(Hash)类型数据 begin***************************************
     */

    /**
     * 将哈希表key中的域field的值设为value。
     * 如果key不存在，一个新的哈希表被创建并进行HSET操作。
     * 如果域field已经存在于哈希表中，旧值将被覆盖。
     * 如果field是哈希表中的一个新建域，并且值设置成功，返回1。
     * 如果哈希表中域field已经存在且旧值已被新值覆盖，返回0。
     *
     * @param string $key
     * @param string $field
     * @param string $val
     */
    public function hSet($key, $field, $val)
    {
        return $this->redis->hSet($key, $field, $val);
    }

    /**
     * 将哈希表key中的域field的值设置为value，当且仅当域field不存在。设置成功返回true
     * 若域field已经存在，该操作无效。返回false
     *
     * @param string $key
     * @param string $field
     * @param string $val
     */
    public function hSetNx($key, $field, $val)
    {
        return $this->redis->hSetNx($key, $field, $val);
    }

    /**
     * 同时将多个field - value(域-值)对设置到哈希表key中。
     * 此命令会覆盖哈希表中已存在的域。
     * 如果key不存在，一个空哈希表被创建并执行HMSET操作。
     * 如果命令执行成功，返回true。
     * 当key不是哈希表(hash)类型时，返回false。
     *
     * @param string $key
     * @param array $vals
     */
    public function hMset($key, $vals)
    {
        return $this->redis->hMset($key, $vals);
    }

    /**
     * 返回哈希表key中给定域field的值。
     * 当给定域不存在或是给定key不存在时，返回false。
     *
     * @param string $key
     * @param string $field
     * @return string
     */
    public function hGet($key, $field)
    {
        return $this->redis->hGet($key, $field);
    }

    /**
     * 返回哈希表key中，一个或多个给定域的值。
     * 如果给定的域不存在于哈希表，那么返回一个false。
     *
     * @param string $key
     * @param array $fields
     * @return array
     */
    public function hMget($key, $fields)
    {
        return $this->redis->hMget($key, $fields);
    }

    /**
     * 返回哈希表key中，所有的域和值。
     * 取得整个HASH表的信息，返回一个以KEY为索引VALUE为内容的数组。
     *
     * @param string $key
     * @return array
     */
    public function hGetAll($key)
    {
        return $this->redis->hGetAll($key);
    }

    /**
     * 返回哈希表key的长度。
     * 当给定key不存在时，返回false。
     *
     * @param string $key
     * @return int
     */
    public function hLen($key)
    {
        return $this->redis->hLen($key);
    }

    /**
     * 删除哈希表key中指定的一个指定域。
     * 若删除成果，返回1。
     * 当给定key不存在时，返回0。
     * 当key中指定域不存在时，返回false。
     *
     * @param string $key
     * @param string $field
     */
    public function hDel($key, $field)
    {
        return $this->redis->hDel($key, $field);
    }

    /**
     * 返回哈希表key中的所有域。
     * 当key存在时，返回哈希表中所有域的表。
     * 当key不存在时，返回false。
     *
     * @param string $key
     * @return array
     */
    public function hKeys($key)
    {
        return $this->redis->hKeys($key);
    }

    /**
     * 返回哈希表key中的所有值。
     * 当key存在时，返回哈希表中所有值。
     * 当key不存在时，返回false。
     *
     * @param string $key
     * @return array
     */
    public function hVals($key)
    {
        return $this->redis->hVals($key);
    }

    /**
     * 查看哈希表key中，给定域field是否存在。
     * 如果哈希表含有给定域，返回true。
     * 如果哈希表不含有给定域，或key不存在，返回false。
     *
     * @param string $key
     * @param string $field
     */
    public function hExists($key, $field)
    {
        return $this->redis->hExists($key, $field);
    }

    /**
     * 为哈希表key中的域field的值加上增量increment。
     * 增量也可以为负数，相当于对给定域进行减法操作。
     * 如果域key存在，field不存在，那么在执行命令前，域的值被初始化为0。
     * 如果域field不是数值类型，则返回false。
     * 如果key不存在，则返回false。
     *
     * @param string $key
     * @param string $field
     * @param int $num
     */
    public function hIncrBy($key, $field, $num)
    {
        return $this->redis->hIncrBy($key, $field, $num);
    }

    /**
     * 浮点型
     * 为哈希表key中的域field的值加上增量increment。
     * 增量也可以为负数，相当于对给定域进行减法操作。
     * 如果域key存在，field不存在，那么在执行命令前，域的值被初始化为0。
     * 如果域field不是数值类型，则返回false。
     * 如果key不存在，则返回false。
     *
     * @param string $key
     * @param string $field
     * @param float $num
     */
    public function hIncrByFloat($key, $field, $num)
    {
        return $this->redis->hIncrByFloat($key, $field, $num);
    }
    /**
     * ***********************操作哈希表(Hash)类型数据 end***************************************
     */

    /**
     * ***********************操作链表(List)类型数据 begin***************************************
     */
    /**
     * 将一个或多个值value插入到列表key的表头(左侧)。
     * 返回列表长度
     *
     * @param string $key
     * @param string $val
     * @return int 列表的长度
     */
    public function lPush($key, $val)
    {
        return $this->redis->lPush($key, $val);
    }

    /**
     * 将值value插入到列表key的表头，当且仅当key存在并且是一个列表。
     * 当key不存在时，lPushx命令什么也不做，返回0
     * 当key存在时，返回列表的长度
     *
     * @param string $key
     * @param string $val
     * @return int 列表的长度
     */
    public function lPushx($key, $val)
    {
        return $this->redis->lPushx($key, $val);
    }

    /**
     * 移除并返回列表key的头元素。
     * 如果LIST有值时，返回列表的头元素。
     * 如果是一个空LIST则返回FLASE。
     *
     * @param string $key
     */
    public function lPop($key)
    {
        return $this->redis->lPop($key);
    }

    /**
     * 将一个或多个值value插入到列表key的底部(右侧)。
     * 返回列表长度
     *
     * @param string $key
     * @param string $val
     * @return int 列表的长度
     */
    public function rPush($key, $val)
    {
        return $this->redis->rPush($key, $val);
    }

    /**
     * 将值value插入到列表key的底部，当且仅当key存在并且是一个列表。
     * 当key不存在时，lPushx命令什么也不做，返回0
     * 当key存在时，返回列表的长度
     *
     * @param string $key
     * @param string $val
     * @return int 列表的长度
     */
    public function rPushx($key, $val)
    {
        return $this->redis->rPushx($key, $val);
    }

    /**
     * 移除并返回列表key的底部元素。
     * 如果LIST有值时，返回列表的底部元素。
     * 如果是一个空LIST则返回FLASE。
     *
     * @param string $key
     */
    public function rPop($key)
    {
        return $this->redis->rPop($key);
    }

    /**
     * 移除并获取列表头部的第一个元素。
     * 如果列表没有元素则会阻塞列表直到等待超时或发现可弹出元素为止。
     * 返回值：[0=>key,1=>value]，超时返回[]
     *
     * @param string $key
     * @param int $time（单位：秒）
     */
    public function blPop($key, $time)
    {
        return $this->redis->blPop($key, $time);
    }

    /**
     * 移除并获取列表尾部的第一个元素。
     * 如果列表没有元素则会阻塞列表直到等待超时或发现可弹出元素为止。
     * 返回值：[0=>key,1=>value]，超时返回[]
     *
     * @param string $key
     * @param int $time（单位：秒）
     */
    public function brPop($key, $time)
    {
        return $this->redis->brPop($key, $time);
    }

    /**
     * 如果KEY存在并且为LIST且有元素，那么返回KEY的长度，为空或者不存在返回0。
     * 如果KEY存在但不是为LIST类型，则返回false。
     *
     * @param string $key
     */
    public function lSize($key)
    {
        return $this->redis->lSize($key);
    }

    /**
     * 根据索引值返回指定KEY LIST中的元素。
     * 0为第一个元素，1为第二个元素。
     * -1为倒数第一个元素，-2为倒数第二个元素。
     * 如果指定了一个不存在的索引值，则返回FLASE。
     *
     * @param string $key
     * @param int $num
     */
    public function lGet($key, $num)
    {
        return $this->redis->lGet($key, $num);
    }

    /**
     * 根据索引值设置新的VAULE
     *
     * @param string $key
     * @param int $num
     * @param string $val
     *            如果设置成功返回TURE，
     *            如果KEY所指向的不是LIST，或者索引值超出LIST本身的长度范围，则返回flase。
     */
    public function lSet($key, $num, $val)
    {
        return $this->redis->lSet($key, $num, $val);
    }

    /**
     * 取得指定索引值范围内的所有元素。
     * 如果key存在时，返回list数组
     * 如果key不存在时，返回空数组
     *
     * @param string $key
     * @param int $start
     * @param int $end
     */
    public function lRange($key, $start, $end)
    {
        return $this->redis->lRange($key, $start, $end);
    }

    /**
     * 返回列表key的长度。
     * 如果key不存在，则key被解释为一个空列表，返回0.
     * 如果key不是列表类型，返回false。
     *
     * @param string $key
     */
    public function lLen($key)
    {
        return $this->redis->lLen($key);
    }

    /**
     * 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
     * 操作成功返回true
     *
     * @param string $key
     * @param int $start
     * @param int $stop
     */
    public function lTrim($key, $start, $stop)
    {
        return $this->redis->lTrim($key, $start, $stop);
    }

    /**
     * 首先要去判断count参数，
     * 如果count参数为0，那么所有符合删除条件的元素都将被移除。
     * 如果count参数为整数,将从左至右删除count个符合条件的元素，
     * 如果为负数则从右至左删除count个符合条件的元素。
     * 删除成功，返回删除个数值
     *
     * @param string $key
     * @param string $val
     * @param int $count
     */
    public function lRem($key, $val, $count)
    {
        return $this->redis->lRem($key, $val, $count);
    }

    /**
     * 返回列表key中，下标为index的元素。
     * 如果index参数的值不在列表的区间范围内(out of range)，返回false。
     * 如果key不存在，则返回false
     *
     * @param string $key
     * @param int $index
     */
    public function lIndex($key, $index)
    {
        return $this->redis->lIndex($key, $index);
    }

    /**
     * 从源key0的最后弹出一个元素，并且把这个元素从目标key1的顶部（左侧）压入目标key1。
     * 成功返回被弹出的元素。
     * 失败返回false。
     *
     * @param string $key0
     * @param string $key1
     */
    public function rpoplpush($key1, $key2)
    {
        return $this->redis->rpoplpush($key1, $key2);
    }

    /**
     * 移除列表中最后一个元素，将其插入另一个列表头部，并返回这个元素。
     * 如果列表没有元素则会阻塞列表直到等待超时或发现可弹出元素为止。
     * 参数：源列表，目标列表，超时时间（单位：秒）
     * 超时返回false
     *
     * @param string $key0
     * @param string $key1
     * @param number $time
     */
    public function brpoplpush($key1, $key2, $time)
    {
        if (empty ($time)) {
            $time = 3;
        }
        return $this->redis->brpoplpush($key1, $key2, $time);
    }
    /**
     * ***********************操作链表(List)类型数据 end*****************************************
     */

    /**
     * ***********************操作集合(Set)类型数据 begin***************************************
     */
    /**
     * 添加一个val到key容器中
     * 如果val不在key容器中，返回1；
     * 如果val已经在key容器中，返回0；
     * 如果key不是set类型，则返回false;
     *
     * @param string $key
     * @param string $val
     */
    public function sAdd($key, $val)
    {
        return $this->redis->sAdd($key, $val);
    }

    /**
     * 移除指定的val从key容器中
     * 如果val在key容器中，返回1。
     * 如果val不存在key容器中，返回0。
     * 如果key不是集合类型，返回false。
     *
     * @param string $key
     * @param string $val
     */
    public function sRem($key, $val)
    {
        return $this->redis->sRem($key, $val);
    }

    /**
     * 将val元素从key1集合移动到key2集合。
     * 如果val元素被成功移除，返回true。
     * 如果val元素不是key1集合的成员，并且没有任何操作对key2集合执行，那么返回false。
     *
     * @param string $key1
     * @param string $key2
     * @param string $val
     */
    public function sMove($key1, $key2, $val)
    {
        return $this->redis->sMove($key1, $key2, $val);
    }

    /**
     * 判断val元素是否是集合key的成员。
     * 如果val元素是集合的成员，返回true。
     * 如果val元素不是集合的成员，或key不存在，返回false。
     *
     * @param string $key
     * @param string $val
     */
    public function sIsMember($key, $val)
    {
        return $this->redis->sIsMember($key, $val);
    }

    /**
     * 返回集合key的基数(集合中元素的数量)。
     * 当key存在时，返回集合的基数。
     * 当key不存在时，返回0。
     * 当key不是集合类型时，返回false。
     *
     * @param string $key
     */
    public function sCard($key)
    {
        return $this->redis->sCard($key);
    }

    /**
     * 随机返回一个元素，并且在SET容器中移除该元素。
     * 当key存在时吗，返回被移除的随机元素。
     * 当key不存在或key是空集时，返回false。
     * 当key不是集合时，返回false。
     *
     * @param string $key
     */
    public function sPop($key)
    {
        return $this->redis->sPop($key);
    }

    /**
     * 随机返回集合中的一个元素。
     * 当key不存在或key是空集时，返回false。
     * 当key不是集合时，返回false。
     *
     * @param string $key
     */
    public function sRandMember($key)
    {
        return $this->redis->sRandMember($key);
    }

    /**
     * 求两个集合的交集
     * 返回一个集合的全部成员，该集合是所有给定集合的交集。
     * 不存在的key被视为空集。
     * 当给定集合当中有一个空集时，结果也为空集。
     * 当给的两个集合中有一个不是集合类型，则返回false。
     *
     * @param string $key1
     * @param string $key2
     */
    public function sInter($key1, $key2)
    {
        return $this->redis->sInter($key1, $key2);
    }

    /**
     * 执行一个交集操作，并把结果存储到一个新的SET容器中。
     * 当执行成时，返回交集中元素的数量。
     * 当给的两个集合中有一个不是集合类型，则返回false。
     *
     * @param string $new_key
     * @param string $key1
     * @param string $key2
     */
    public function sInterStore($new_key, $key1, $key2)
    {
        return $this->redis->sInterStore($new_key, $key1, $key2);
    }

    /**
     * 返回一个集合的全部成员，该集合是所有给定集合的并集。
     * 当执行成时，返回并集中元素的数量。
     * 不存在的key被视为空集。
     * 当给的两个集合中有一个不是集合类型，则返回false。
     *
     * @param string $key1
     * @param string $key2
     */
    public function sUnion($key1, $key2)
    {
        return $this->redis->sUnion($key1, $key2);
    }

    /**
     * 执行一个并集操作就和sUnion()一样，但是结果储存在新的集合中。
     *
     * @param string $new_key
     * @param string $key1
     * @param string $key2
     */
    public function sUnionStore($new_key, $key1, $key2)
    {
        return $this->redis->sUnionStore($new_key, $key1, $key2);
    }

    /**
     * 执行差集操作在N个不同的SET容器之间，并返回结果。
     * 这个操作取得结果是第一个SET相对于其他参与计算的SET集合的差集。
     * 当给的两个集合中有一个不是集合类型，则返回false。
     *
     * @param string $key1
     * @param string $key2
     */
    public function sDiff($key1, $key2)
    {
        return $this->redis->sDiff($key1, $key2);
    }

    /**
     * 与sDiff函数功能一直，只是结果为一个新的SET集合，存储到新的集合中。
     * 当执行成功时，返回差集中元素的数量。
     * 当给的两个集合中有一个不是集合类型，则返回false。
     *
     * @param string $new_key
     * @param string $key1
     * @param string $key2
     */
    public function sDiffStore($new_key, $key1, $key2)
    {
        return $this->redis->sDiffStore($new_key, $key1, $key2);
    }

    /**
     * 返回SET集合中的所有元素。
     *
     * @param string $key
     */
    public function sMembers($key)
    {
        return $this->redis->sMembers($key);
    }
    /**
     * ***********************操作集合(Set)类型数据 end***************************************
     */

    /**
     * ***********************操作有序集合(zSet)类型数据 begin***************************************
     */
    /**
     * 增加一个或多个元素，如果该元素已经存在，更新它的socre值
     * 虽然有序集合有序，但它也是集合，不能重复元素，添加重复元素只会更新原有元素的score值
     * 当val不存在key中，则返回1；
     * 当val已经存在key中，则返回0；
     * 当key存在但不是有序集类型时，返回一个false。
     *
     * @param unknown $key
     * @param unknown $score
     * @param unknown $val
     */
    public function zAdd($key, $score, $val)
    {
        return $this->redis->zAdd($key, $score, $val);
    }

    /**
     * 取得特定范围内的排序元素,0代表第一个元素,1代表第二个以此类推。-1代表最后一个,-2代表倒数第二个...
     * 按升序排序
     *
     * @param string $key
     * @param int $start
     * @param int $end
     * @param bool $withscores
     *            true返回score信息
     */
    public function zRange($key, $start, $end, $withscores = false)
    {
        return $this->redis->zRange($key, $start, $end, $withscores);
    }

    /**
     * 从有序集合中删除指定的成员。
     * 当val存在key中，删除成功，则返回1；
     * 当val不存在key中，删除失败，则返回0；
     * 当key不存在时，则返回0。
     * 当key存在但不是有序集类型时，返回一个false。
     *
     * @param string $key
     * @param string $val
     */
    public function zDelete($key, $val)
    {
        return $this->redis->zDelete($key, $val);
    }

    /**
     * 返回key对应的有序集合中指定区间的所有元素。
     * 这些元素按照score从高到低的顺序进行排列。
     * 对于具有相同的score的元素而言，将会按照递减的字典顺序进行排列。
     * 该命令与ZRANGE类似，只是该命令中元素的排列顺序与前者不同。
     * 按降序排序
     *
     * @param string $key
     * @param int $start
     * @param int $end
     * @param bool $withscores
     *            true返回score信息
     */
    public function zRevRange($key, $start, $end, $withscores = false)
    {
        return $this->redis->zRevRange($key, $start, $end, $withscores);
    }

    /**
     * 返回key对应的有序集合中score介于min和max之间的所有元素（包哈score等于min或者max的元素）。
     * 元素按照score从低到高的顺序排列。
     * 如果元素具有相同的score，那么会按照字典顺序排列。
     *
     * @param string $key
     * @param int $min
     * @param int $max
     * @param array $options
     *            => TRUE, 'limit' => array(1, 1));
     */
    public function zRangeByScore($key, $min, $max, $options = array())
    {
        return $this->redis->zRangeByScore($key, $min, $max, $options);
    }

    /**
     * 返回key对应的有序集合中score介于min和max间的元素的个数。
     *
     * @param string $key
     * @param int $min
     * @param int $max
     */
    public function zCount($key, $min, $max)
    {
        return $this->redis->zCount($key, $min, $max);
    }

    /**
     * 移除key对应的有序集合中scroe位于min和max（包含端点）之间的所有元素。
     * 移除成功，则返回移除个数；
     * 如果区间内没有score值，则返回0；
     * 如果key不存在，则返回0；
     * 如果key不是有序集合，则返回false；
     *
     * @param string $key
     * @param int $min
     * @param int $max
     */
    public function zRemRangeByScore($key, $min, $max)
    {
        return $this->redis->zRemRangeByScore($key, $min, $max);
    }

    /**
     * 移除key对应的有序集合中rank值介于start和end之间的所有元素。
     * start和end均是从0开始的，并且两者均可以是负值。
     * 当索引值为负值时，表明偏移值从有序集合中score值最高的元素开始。
     * 例如：-1表示具有最高score的元素，而-2表示具有次高score的元素，以此类推。
     *
     * 移除成功，则返回移除个数；
     * 如果区间内没有值，则返回0；
     * 如果key不存在，则返回0；
     * 如果key不是有序集合，则返回false；
     *
     * @param string $key
     * @param int $start
     * @param int $end
     */
    public function zRemRangeByRank($key, $start, $end)
    {
        return $this->redis->zRemRangeByRank($key, $start, $end);
    }

    /**
     * 返回存储在key对应的有序集合中的元素的个数。
     * 如果key不存在，则返回0；
     * 如果key不是有序集合，则返回false；
     *
     * @param string $key
     */
    public function zSize($key)
    {
        return $this->redis->zSize($key);
    }

    /**
     * 返回key对应的有序集合中val的score值。
     * 如果val在有序集合中不存在，那么将会返回false。
     * 如果key不存在，则返回false；
     * 如果key不是有序集合，则返回false；
     *
     * @param string $key
     * @param string $val
     */
    public function zScore($key, $val)
    {
        return $this->redis->zScore($key, $val);
    }

    /**
     * 返回key对应的有序集合中val元素的索引值，元素按照score从低到高进行排列。
     * rank值（或index）是从0开始的，这意味着具有最低score值的元素的rank值为0。
     * 使用zRank可以获得从低到高排列的元素的rank（或index）。
     * val存在key有序集合中，则返回从低到高排列的元素的rank；
     * key不存在或则不是有序集合，则返回false；
     * 如果val在有序集合中不存在，那么将会返回false。
     *
     * @param string $key
     * @param string $val
     */
    public function zRank($key, $val)
    {
        return $this->redis->zRank($key, $val);
    }

    /**
     * 返回key对应的有序集合中val元素的索引值，元素按照score从低到高进行排列。
     * rank值（或index）是从0开始的，这意味着具有最低score值的元素的rank值为0。
     * 使用zRevRank可以获得从高到低排列的元素的rank（或index）。
     * val存在key有序集合中，则返回从低到高排列的元素的rank；
     * key不存在或则不是有序集合，则返回false；
     * 如果val在有序集合中不存在，那么将会返回false。
     *
     * @param string $key
     * @param string $val
     */
    public function zRevRank($key, $val)
    {
        return $this->redis->zRevRank($key, $val);
    }

    /**
     * 将key对应的有序集合中val元素的scroe加上increment。
     * 如果指定的val不存在，那么将会添加该元素，并且其score的初始值为increment。
     * 如果key不存在，那么将会创建一个新的有序列表，其中包含val这一唯一的元素。
     * 如果key对应的值不是有序列表，返回false。
     * 指定的score的值应该是能够转换为数字值的字符串，并且接收双精度浮点数。
     * 同时，你也可用提供一个负值，这样将减少score的值。
     * 操作成功，返回score值
     *
     * @param unknown $key
     * @param unknown $score
     * @param unknown $val
     */
    public function zIncrBy($key, $increment, $val)
    {
        return $this->redis->zIncrBy($key, $increment, $val);
    }

    /**
     * 对keys对应的多个有序集合计算合集，并将结果存储在new_key中。
     * 在传递输入keys之前必须提供输入keys的个数和其它可选参数。
     * 在默认情况下，元素的结果score是包含该元素的所有有序集合中score的和。
     * 如果new_key已经存在，那么它将会被重写。
     * 操作成功，返回合集集合中元素个数;
     * 如果keys中有一个不是有序集合，则返回false;
     *
     * @param string $new_key
     * @param array $keys
     * @param array $weights
     */
    public function zUnion($new_key, $keys)
    {
        return $this->redis->zUnion($new_key, $keys);
    }

    /**
     * 计算多个由keys指定的有序集合的交集，并且将结果存储在new_key中。
     * 在该命令中，在你传递输入keys之前，必须提供输入keys的个数和其它可选的参数。
     * 在默认情况下，一个元素的结果score是具有该元素的所有有序集合的score的和。
     * 如果目标已经存在，那么它将会被重写。
     * 操作成功，返回合集集合中元素个数。
     * 如果keys中有一个不是有序集合，则返回false;
     *
     * @param string $new_key
     * @param array $keys
     */
    public function zInter($new_key, $keys)
    {
        return $this->redis->zInter($new_key, $keys);
    }
    /**
     * ***********************操作有序集合(zSet)类型数据 end***************************************
     */
}

?>